﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WASapTKB.Domain
{
    class FrmGAMainNotUse
    {
    }
}


#region Not use
//using System;
//using System.Collections.Generic;
//using System.ComponentModel;
//using System.Data;
//using System.Drawing;
//using System.Linq;
//using System.Text;
//using System.Windows.Forms;

//namespace WASapTKB
//{
//    public partial class FrmGAMain : Form
//    {
//        public FrmGAMain()
//        {
//            InitializeComponent();

//            // Khởi tạo tập dữ liệu ban đầu.
//            InitInputData();

//            bntStart.Focus();
//        }

//        /*
//          ********* Giới hạn đầu vào *********
//          ************************************
//          * 10 nhóm lớp. Trong đó, 8 lớp có sỉ số lá 50 và 2 lớp có chỉ số là 100.
//          * 5 giảng viên.
//          * 5 môn (có số tiết tương ứng là {2,3,4,5,6}.
//          * Nhóm lớp x phòng học x môn = mảng 3 chiều [giangvien, nhomlop, mon]. Với giangvien: dòng; nhomlop: cột; mon: chiều sâu.
//          * Tính mon = index / (5 x 10); giangvien= index / 10; nhomlop = index % 10. index bắt đầu từ 0.
//          * Tính giá trị sự kiện = (mon x (5x10) + giangviên x 10 + nhomlop) - 1. index bắt đầu từ 0.
//          * 5 phòng học. Trong đó, 4 phòng có sức chứa là 50 và 1 phòng có sức chứa là 100.
//          * 5 ngày trong tuần (từ thứ 2 đến thứ 6).
//          * 10 buổi vì mỗi ngày 2 buổi.
//          * 250 tiết = 50 tiết x 5 phòng. Vì mỗi buổi 5 tiết.
//          * 10 cá thể trong quần thể.
//          * 50 sự kiện [nhomlop, phonghoc, mon] x 4 (số tiết trung bình của mỗi môn) ~ 200 tiết cần phải được sắp xếp.
//         */
//        #region Khởi tạo dữ liệu đầu vào
//        int iCountClass = 10;
//        int iCountTeacher = 5;
//        int iCountSubject = 5;
//        int iCountDay = 5; // 1 tuần 5 ngày.
//        int iCountDuration = 2; // 1 ngày 2 buổi.
//        int iCountUnit = 5; // 1 buổi 5 tiết.
//        int iCountRoom = 1;
//        int iCountEvent = 50;
//        int iCountElement = 100;// Số lượng cá thể trong quần thể.

//        int iContraintRate1 = 10;
//        int iContraintRate2 = 20;
//        int iContraintRate3 = 30;
//        int iContraintRate4 = 40;
//        int iContraintRate5 = 0;
//        int iLaiGhepRate = 40; // Tỉ lệ lai ghép trên phân nửa quần thể.
//        int iDotBienRate = 40; // Tỉ lệ đột biến trên phân nửa quần thể.

//        List<int> LstUnitClass = new List<int>(); // Sỉ số của nhóm lớp.
//        List<int> LstTeacher = new List<int>(); // Giảng viên.
//        List<int> LstSubject = new List<int>(); // Môn học.
//        List<int> LstSubjectUnit = new List<int>(); // Số tiết ứng với mỗi môn học (LstSubject).
//        List<int> LstUnitRoom = new List<int>(); // Sức chứa của phòng học.
//        List<int> LstRoom = new List<int>(); // Phòng học.
//        List<int> LstUnit = new List<int>(); // Tiết học.
//        List<int> LstEvent = new List<int>(); // Tập sự kiện.
//        Dictionary<int, List<int>> LstElements; // Quần thể.
//        List<Dictionary<int, int>> LstElementUnitErrors; // Tập các tiết phạm lỗi trong mỗi thời khóa biểu.
//        List<int> LstSchedule;

//        #endregion Khởi tạo dữ liệu đầu vào.

//        /*********************************************************************************************/
//        #region Các chức năng chính của chương trình.
//        // Mã hóa dữ liệu.
//        void InitInputData()
//        {
//            // Khởi tạo giảng viên.
//            for (int i = 0; i < iCountTeacher; i++)
//            {
//                LstTeacher.Add(i);
//            }
//            // Khởi tạo nhóm lớp.
//            for (int i = 0; i < iCountClass; i++)
//            {
//                LstUnitClass.Add(50);// Mỗi lớp có sỉ số là 50.
//            }
//            // Hai nhóm sv đầu tiên có sỉ số là 100.
//            LstUnitClass[0] = 100;
//            LstUnitClass[1] = 100;
//            // Khởi tạo môn học.
//            for (int i = 0; i < iCountSubject; i++)
//            {
//                LstSubject.Add(i);
//                LstSubjectUnit.Add(2);// Số tiết của môn học tương ứng (2,2,2,2,2).
//            }
//            // Khởi tạo phòng học.
//            for (int i = 0; i < iCountRoom; i++)
//            {
//                LstUnitRoom.Add(50);
//                LstRoom.Add(i);

//                cbbRoom.Items.Add(i + 1);
//            }
//            LstUnitRoom[0] = 100;// Phòng đầu tiên có sức chứa là 100.

//            // Khởi tạo tập sự kiện với giá trị ngẫu nhiên.
//            Random radom = new Random();
//            for (int i = 0; i < iCountEvent; i++)
//            {
//                int iIndexSubject = radom.Next(iCountSubject - 1);
//                int iIndexClass = radom.Next(iCountClass - 1);
//                int iIndexTeacher = radom.Next(iCountTeacher - 1);
//                int iEventValue = eventValue(iIndexClass, iIndexTeacher, iIndexSubject);
//                // Lặp lại số tiết cho từng môn.
//                int iNumUnit = LstSubjectUnit[iIndexSubject];
//                for (int j = 0; j < iNumUnit; j++)
//                {
//                    LstEvent.Add(iEventValue);
//                    // Khởi mọi sự kiện đều không có lỗi.
//                }
//            }
//        }

//        // Giải thuật chính.
//        bool GenericAlgorithms()
//        {
//            // Khởi tạo quần thể.
//            LstElementUnitErrors = new List<Dictionary<int, int>>();
//            LstElements = Population(LstElementUnitErrors);
//            // Tìm kiếm giải pháp
//            LstSchedule = SearchResult();
//            return LstSchedule != null;
//        }

//        // Khởi tạo cá thể hay thời khóa biểu.
//        List<int> Individual(Dictionary<int, int> pLstUnitError)
//        {
//            List<int> LstSchedule = new List<int>();
//            //List<int> lstNumUnitTemp = new List<int>() { 2, 2, 2, 2, 2 }; // Số lần lặp (số tiết) sự kiện.
//            // Tạo bản sao của tập sự kiện.
//            List<int> lstEvent = new List<int>();
//            for (int i = 0; i < LstEvent.Count; i++)
//            {
//                lstEvent.Add(LstEvent[i]);
//            }
//            int iUnit = iCountUnit * iCountDuration * iCountDay * iCountRoom;
//            int iEventValue, iUnitError;
//            // Lặp qua các sự kiện được cho.
//            for (int i = 0; i < iUnit; i++)
//            {
//                iEventValue = -1;
//                iUnitError = -1;// Nếu tiết rỗng thì không xét lỗi.
//                if (lstEvent.Count > 0)
//                {
//                    int iIndex = (new Random()).Next(0, lstEvent.Count - 1); // Lấy 1 sự kiện ngẫu nhiên.
//                    iEventValue = lstEvent[iIndex];
//                    iUnitError = 0;// Khởi tạo mọi tiết đều chưa phạm lỗi.
//                    lstEvent.RemoveAt(iIndex);// Nếu đã lấy hết số tiết thì loại bỏ sự kiện.
//                }
//                LstSchedule.Add(iEventValue); // Thêm sự kiện vào thời khóa biểu.
//                pLstUnitError.Add(i, iUnitError);// Gán lỗi cho tiết thứ i.
//            }
////            int icount = CountEmpty(LstSchedule);
//            return LstSchedule;
//        }

//        // Khởi tạo quần thể. Tạo cá thể và đánh giá độ thích nghi của cá thể.
//        List<KeyValuePair<int, List<int>>> Population(List<Dictionary<int, int>> pLstElementUnitErrors)
//        {
//            Dictionary<int, List<int>> lstElements = new Dictionary<int, List<int>>();
//            for (int i = 0; i < iCountElement; i++)
//            {
//                Dictionary<int, int> lstUnitError = new Dictionary<int, int>();
//                List<int> schedule = Individual(lstUnitError);
//                lstElements.Add(Contraints(schedule, lstUnitError), schedule);
//                pLstElementUnitErrors.Add(lstUnitError);// Khởi tạo mọi tiết đều chưa có lỗi.
//            }
//            return lstElements;
//        }

//        // Đánh giá độ thích nghi của cá thể.
//        int Contraints(List<int> pSchedule, List<int> pLstUnitError)
//        {
//            //int result = iContraintRate1 * ContraintC1() + iContraintRate2 * ContraintC2(pSchedule) + iContraintRate3 * ContraintC3(pSchedule) + iContraintRate4 * ContraintC4(pSchedule) + iContraintRate5 * ContraintC5();
//            //return result / 100;
//            return ContraintC4(pSchedule, pLstUnitError);
//        }

//        // Quá trình tìm kiếm thời khóa biểu.
//        List<int> SearchResult()
//        {
//            // Điều kiện dừng.
//            for (int i = 0; i < 100000; i++)
//            {
//                for (int j = 0; j < LstElements.Count; j++)
//                {
//                    if (LstElements[j].Key < 5)
//                    {
//                        List<int> result = LstElements[j].Value;
//                        string sResult = ConvertSchedule(result);
//                        return result;
//                    }
//                }
//                SelectElement();
//                LaiGhep();
//                DotBien();
//            }
//            SelectElement();
//            label4.Text = LstElements[0].Key.ToString();
//            return null;
//        }

//        // Sắp xếp cá thể trong quần thể theo thứ tự giảm dần độ thích nghi (tăng dần vi phạm).
//        void SortElements()
//        {
//            LstElements.Sort((p, q) => p.Key.CompareTo(q.Key));
//        }

//        // Chọn lựa cá thể.
//        void SelectElement()
//        {
//            SortElements();
//            while (LstElements.Count > iCountElement)
//            {
//                LstElements.RemoveAt(LstElements.Count - 1);
//            }
//            //for (int i = iCountElement; i < LstElements.Count; i++)
//            //{
//            //}
//        }

//        // Lai ghép 2 sự kiện cho ra 2 sự kiện mới.
//        List<List<int>> LaiGhep(List<int> pSchedule1, List<int> pSchedule2, List<KeyValuePair<int, int>> pLstUnitError1, List<KeyValuePair<int, int>> pLstUnitError2)
//        {
//            List<List<int>> result;
//            List<int> lst1 = new List<int>();// Sự kiện con đầu tiên.
//            List<int> lst2 = new List<int>();// Sự kiện con thứ 2.
//            int iUnit = iCountUnit * iCountDuration * iCountDay * iCountRoom;
//            int iCount = iUnit / 2;
//            for (int i = 0; i < iCount; i++)
//            {
//                // Con đầu tiên = nửa đầu của sự kiện 1 và nửa sau của sự kiện 2.
//                lst1.Add(pSchedule1[i * 2]);
//                lst1.Add(pSchedule1[iUnit  - i - 1]);
//                // Con đầu tiên = nửa sau của sự kiện 1 và nửa đầu của sự kiện 2.
//                lst2.Add(pSchedule2[iUnit - i - 1]);
//                lst2.Add(pSchedule2[i * 2]);

//            }
//            result = new List<List<int>>() { lst1, lst2 };
//            return result;
//        }

//        // Lai ghép quần thể. Lấy phân nửa thời khóa biểu đầu lai ghép với phân nửa sau.
//        void LaiGhep()
//        {
//            List<KeyValuePair<int, List<int>>> children = new List<KeyValuePair<int, List<int>>>();
//            int iCount = ((iCountElement / 2) * iLaiGhepRate) / 100;
//            for (int i = 0; i < iCount; i++)
//            {
//                // Lai ghép cha mẹ sinh ra 2 con.
//                List<List<int>> lst = LaiGhep(LstElements[i].Value, LstElements[iCountElement - i - 1].Value);
//                foreach (var item in lst)
//                {
//                    // Thêm từng con vào quần thể (có đánh giá độ thích nghi).
//                    children.Add(new KeyValuePair<int, List<int>>(Contraints(item), item));
//                }
//            }
//            LstElements.AddRange(children);
//        }

//        // Đột biến 1 thời khóa biểu cho ra 1 thời khóa biểu mới.
//        List<int> DotBien(List<int> pSchedule)
//        {
//            List<int> result = new List<int>();
//            int iUnit = iCountUnit * iCountDuration * iCountDay * iCountRoom;
//            //int iCount = ((iUnit / 2) * iDotBienRate) / 100;// Gây đột biến một vài sự kiện.
//            int iCount = (iUnit / 2);
//            int i;
//            for (i = 0; i < iCount; i++)
//            {
//                result.Add(pSchedule[i]);
//                result.Add(pSchedule[iUnit - i - 1]);
//            }
//            //iCount = iUnit - i;
//            //for (int j = i; j < iCount; j++)
//            //{
//            //    result.Add(pSchedule[j]);
//            //}
//            return result;
//        }

//        // Đột biến một số cá thể trong quần thể.
//        void DotBien()
//        {
//            List<KeyValuePair<int, List<int>>> children = new List<KeyValuePair<int, List<int>>>();
//            int iCount = ((iCountElement / 2) * iDotBienRate) / 100;
//            for (int i = 0; i < iCount; i++)
//            {
//                List<int> schedule = DotBien(LstElements[i].Value);
//                children.Add(new KeyValuePair<int, List<int>>(Contraints(schedule), schedule));
//                schedule = DotBien(LstElements[iCountElement - i - 1].Value);
//                children.Add(new KeyValuePair<int, List<int>>(Contraints(schedule), schedule));
//            }
//            LstElements.AddRange(children);
//        }
//        #endregion Các chức năng chính của chương trình.
//        /*********************************************************************************************/

//        #region Các ràng buộc của bài toán.
//        // Ràng buộc C1
//        int ContraintC1()
//        {
//            return 0;
//        }
//        // Ràng buộc C2: Giảng viên không thể dạy ở nhiều phòng cùng thời điểm.
//        int ContraintC2(List<int> pLstSchedule)
//        {
//            int result = 0;
//            int iUnit = iCountUnit * iCountDuration * iCountDay;
//            // Lặp qua từng tiết.
//            for (int i = 0; i < iUnit; i++)
//            {
//                List<int> lstTeacher = new List<int>();
//                // Lặp qua các phòng.
//                for (int j = 0; j < iCountRoom; j++)
//                {
//                    int iEventValue = j * iUnit + i;// Lấy index của sự kiện.
//                    if (pLstSchedule[iEventValue] == -1) continue;
//                    int iIndexTeacher = indexTeacher(pLstSchedule[iEventValue]); // Lấy index của giảng viên ứng với sự kiện đang xét.
//                    if (lstTeacher.Contains(iIndexTeacher))
//                        result++;
//                    else
//                        lstTeacher.Add(iIndexTeacher);
//                }
//            }
//            return 0;
//        }
//        // Ràng buộc C3: Sức chứa của phòng phải đủ chỗ ngồi cho lớp
//        int ContraintC3(List<int> pLstSchedule)
//        {
//            int result = 0;
//            int iUnit = iCountUnit * iCountDuration * iCountDay * iCountRoom;
//            for (int i = 0; i < iUnit; i++)
//            {
//                if (pLstSchedule[i] == -1) continue;
//                int iIndexClass = indexClass(pLstSchedule[i]); // Lấy index của nhóm lớp ứng với sự kiện đang xét.
//                int iIndexRoom = indexRoom(i); // Lấy index của phòng học từ chỉ số của sự kiện.
//                if (LstUnitClass[iIndexClass] > LstUnitRoom[iIndexRoom])
//                    result++;
//            }
//            return result;
//        }

//        // Kiểm tra số tiết lặp lại
//        bool CheckEventValue(List<int> pLstSchedule, int pEventValue, int pIndex, int pLength)
//        {
//            for (int i = pIndex; i < pLength; i++)
//            {
//                if (pLstSchedule[i] != pEventValue)// Nếu có 1 giá trị khác với giá trị sự kiện truyền vào thì trả về false.
//                    return false;
//            }
//            return true;
//        }
//        // Ràng buộc C4: Mỗi sự kiện phải lặp lại 2 hoặc 3 lần (ứng với 2 hoặc 3 tiết học) trong buổi học.
//        int ContraintC4(List<int> pLstSchedule, Dictionary<int, int> pLstUnitError)
//        {
//            int result = 0;
//            int iDurationCount = iCountDuration * iCountDay;// Tổng số buổi trong tuần.
//            int iUnit = 0;// Chỉ số tiết cho toàn thời khóa biểu.
//            int k, iEventValue, iSubjectCount;// Chỉ số tiết, giá trị sự kiện, số tiết của môn tương ứng.
//            // Lặp qua các phòng học.
//            for (int i = 0; i < iCountRoom; i++)
//            {
//                // Lặp qua các buổi học (10 buổi: 0 -> 9).
//                for (int j = 0; j < iDurationCount; j++)
//                {
//                    // Lặp qua các tiết trong buổi.
//                    for (k = 0; k < iCountUnit; k++)
//                    {
//                        iEventValue = pLstSchedule[iUnit];
//                        if (iEventValue != -1)// Nếu tiết khác rỗng thì mới xét.
//                        {
//                            // Lấy số tiết của môn học trong sự kiện.
//                            iSubjectCount = LstSubjectUnit[indexSubject(iEventValue)];
//                            // Nếu số tiết còn lại nhỏ hơn số tiết mà môn yêu cầu thì phạt.
//                            if ((iCountUnit - k) < iSubjectCount)
//                            {
//                                result++;
//                                pLstUnitError[iUnit] += 1;
//                            }
//                            else
//                            {
//                                List<int> lstUnitErrorTemp = new List<int>();// Danh tiết phạm lỗi tạm thời.
//                                lstUnitErrorTemp.Add(iUnit);// Đầu tiên là tiết đang xét.
//                                // Xét các tiết tiếp theo có cùng giá trị không.
//                                for (int t = 1; t < iSubjectCount; t++)
//                                {
//                                    if (pLstSchedule[iUnit + t] != iEventValue)// Nếu không cùng giá trị.
//                                    {
//                                        result++;
//                                        break;
//                                    }
//                                    else
//                                    {
//                                        lstUnitErrorTemp.Add(iUnit + t);
//                                        k++;
//                                        iUnit++;
//                                    }
//                                }// endfor
//                                // Nếu số tiết phạm lỗi tạm thời < số tiết của môn thì xem như các tiết đó đều phạm lỗi.
//                                if (lstUnitErrorTemp.Count < iSubjectCount)
//                                {
//                                    foreach (var item in lstUnitErrorTemp)
//                                    {
//                                        pLstUnitError[item] += 1;
//                                    }
//                                }
//                            }// endelse
//                        }// endif
//                        iUnit++;// Xét tiết tiếp theo.
//                    }// endfor tiết
//                    if (k == iCountUnit)// Tiết cuối cùng trong buổi là rỗng.
//                        continue;// Qua buổi tiếp theo.
//                }
//            }
//            return result;
//        }
//        // Ràng buộc C5
//        int ContraintC5()
//        {
//            return 0;
//        }
//        #endregion Các ràng buộc của bài toán.

//        #region Bổ sung
//        // Kiểm tra số tiết còn trống trong thời khóa biểu.
//        int CountEmpty(List<int> pSchedule)
//        {
//            int result = 0;
//            foreach (var item in pSchedule)
//            {
//                if (item == -1) result++;
//            }
//            return result;
//        }
//        #endregion Bổ sung

//        #region Quy đổi từ mảng 2 chiều (tiết học).
//        // Đổi từ vị trí tiết ra tiết chưa có phòng.
//        int indexUnitValue(int pUnitValueTotal)
//        {
//            return pUnitValueTotal % (iCountDay * iCountDuration * iCountUnit);
//        }
//        // Đổi từ vị trí tiết ra phòng.
//        int indexRoom(int pUnitValueTotal)
//        {
//            return pUnitValueTotal / (iCountDay * iCountDuration * iCountUnit);
//        }
//        // Đổi từ tiết chưa có phòng và phòng ra tiết có phòng.
//        int unitValueTotal(int pIndexUnit, int pIndexRoom)
//        {
//            return (pIndexRoom * iCountDay * iCountDuration * iCountUnit) + pIndexUnit;
//        }
//        #endregion Quy đổi từ mảng 2 chiều (tiết học).

//        #region Quy đổi giá trị từ mảng 3 chiều.
//        // Lấy giá trị của sự kiện từ chỉ số của mảng 3 chiều.
//        int eventValue(int pClass, int pTeacher, int pSubject)
//        {
//            //if ((pSubject * (iCountTeacher * iCountClass) + pTeacher * (iCountClass) + pClass) > 249)
//            //{
//            //}
//            return (pSubject * (iCountTeacher * iCountClass) + pTeacher * (iCountClass) + pClass);
//        }
//        // Lấy index (tính từ 0) của giangvien từ mảng 3 chiều.
//        int indexTeacher(int pValue)
//        {
//            return (pValue % (iCountTeacher * iCountClass)) / 10;
//        }
//        // Lấy index (tính từ 0) của nhomlop từ mảng 3 chiều.
//        int indexClass(int pValue)
//        {
//            return (pValue % (iCountTeacher * iCountClass)) % 10;
//        }
//        // Lấy index (tính từ 0) của mon từ mảng 3 chiều.
//        int indexSubject(int pValue)
//        {
//            return pValue / (iCountTeacher * iCountClass);
//        }
//        #endregion Quy đổi giá trị từ mảng 3 chiều.

//        #region Giải mã dữ liệu
//        // Giải mã thời khóa biểu.
//        string ConvertSchedule(List<int> pSchedule)
//        {
//            string result = string.Empty;
//            string sUnit, sEvent;
//            for (int i = 0; i < pSchedule.Count; i++)
//            {
//                sUnit = ConvertUnit(i);
//                sEvent = ConvertEventValue(pSchedule[i]);
//                result += sUnit + "->" + sEvent + "\r\n";
//            }
//            return result;
//        }
//        // Giải mã tiết.
//        string ConvertUnit(int pUnitValueTotal)
//        {
//            string result = "[";
//            int iUnitValue = indexUnitValue(pUnitValueTotal);
//            result += "Phong_" + indexRoom(pUnitValueTotal);
//            result += " | ";
//            result += "Thu_" + (iUnitValue / (iCountDuration * iCountUnit)) + 2;
//            result += " | ";
//            result += "Buoi_" + (iUnitValue % (iCountDuration * iCountUnit)) / 5;
//            result += " | ";
//            result += "Tiet_" + (iUnitValue % (iCountDuration * iCountUnit)) % 5;
//            result += "]";
//            return result;
//        }
//        // Giải mã giá trị sự kiện.
//        string ConvertEventValue(int pEventValue)
//        {
//            if (pEventValue == -1)
//                return string.Empty;
//            string result = "[";
//            result += "GV" + indexTeacher(pEventValue);
//            result += ",";
//            result += "Lop" + indexClass(pEventValue);
//            result += ",";
//            result += "Mon" + indexSubject(pEventValue);
//            result += "]";
//            return result;
//        }
//        #endregion Giải mã dữ liệu

//        #region Tương tác với người dùng.
//        // Bắt đầu chạy giải thuật.
//        private void bntStart_Click(object sender, EventArgs e)
//        {
//            bntStart.Enabled = cbbRoom.Enabled = false;
//            dataGridView1.DataSource = null;
//            cbbRoom.SelectedIndex = -1;
//            cbbRoom.Enabled = GenericAlgorithms();
//            bntStart.Enabled = true;

//            if (!cbbRoom.Enabled)
//            {
//                if (DialogResult.OK == MessageBox.Show("Không tìm thấy kết quả!\r\nBạn có muồn thử lại không?", "Thông báo", MessageBoxButtons.OKCancel, MessageBoxIcon.Information))
//                    bntStart_Click(sender, e);
//            }
//            else
//            {
//                cbbRoom.SelectedIndex = 0;
//                cbbRoom.Focus();
//            }
//        }
//        // Xem kết quả thời khóa biểu theo từng phòng.
//        private void cbbRoom_SelectedIndexChanged(object sender, EventArgs e)
//        {
//            ShowSchedule(cbbRoom.SelectedIndex);
//        }
//        // Hiển thị thời khóa biểu của 1 phòng học dưới dạng lưới dữ liệu.
//        void ShowSchedule(int pIndexRoom)
//        {
//            if (pIndexRoom < 0)
//                return;
//            if (LstSchedule == null)
//                return;
//            DataTable dt = new DataTable();
//            int iUnitCount = iCountDuration * iCountUnit;
//            // Tạo 10 cột ứng với 10 tiết học.
//            for (int i = 0; i < iUnitCount; i++)
//            {
//                dt.Columns.Add("Tiết " + i);
//            }
//            int iUnit = pIndexRoom * (iCountDay * iUnitCount);
//            for (int i = 0; i < iCountDay; i++)
//            {
//                object[] a = new object[iUnitCount];
//                List<int> lstThu = new List<int>();
//                for (int j = 0; j < iUnitCount; j++)
//                {
//                    a[j] = ConvertEventValue(LstSchedule[iUnit++]);
//                }
//                //rowThu.ItemArray = a;
//                dt.Rows.Add(a);
//            }
//            dataGridView1.DataSource = dt;
//            label2.Text = "Số sự kiện: " + LstEvent.Count;
//        }
//        #endregion Tương tác với người dùng.
//    }
//}
#endregion Not use
